/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Modele;

import java.util.ArrayList;

/**
 *
 * @author david
 */
public class Grille {
    
    private Case[][] damier = new Case[10][10];
    private boolean tourBlanc = true;
    private ArrayList<Pion> listePionsBlanc = new ArrayList<Pion>();
    private ArrayList<Pion> listePionsNoir = new ArrayList<Pion>();
    private ArrayList<Pion> listePionBlancObligatoire = new ArrayList<Pion>(); // Pion que l'on est obligé de bougé (prise de pion)
    private ArrayList<Pion> listePionNoirObligatoire = new ArrayList<Pion>();
    
    
    
    //private ArrayList<Pion> 
    
    public Grille(){ creerDamier(); }

    private void creerDamier()
    {
        // On créé toutes les cases
        for(int i = 0; i<10; i++)        
            for( int j = 0 ; j < 10 ; j++)
            {  
                damier[i][j] = new Case(i+j);
                if( (i + j)%2 != 0 ) // Si on est bien sur une case noire (inutile de créer les cases blanches en mémoire)
                {                    
                    if( i < 4 ){ // On ajoute un pion blanc
                       listePionsBlanc.add(new Pion(Pion.CouleurPion.NOIR));
                       int indiceDernierElement = listePionsBlanc.size()-1;
                       damier[i][j].setPion( listePionsBlanc.get(indiceDernierElement )); 
                    }else if( i > 5){ // On ajoute un pion noir
                       listePionsNoir.add(new Pion(Pion.CouleurPion.BLANC));
                       int indiceDernierElement = listePionsNoir.size()-1;
                       damier[i][j].setPion( listePionsNoir.get(indiceDernierElement ));                          
                    }
                }                
            }       
    }
    
    
    public Case getCase(int ligne , int colonne){ 
        if( ligne >= 0 && ligne < 10 && colonne >= 0 && colonne < 10 ) // On sécurise quand même
            return damier[ligne][colonne];   
        return null;
    }
    
    @Override
    public String toString(){
        String mess = new String();
        mess += "\n\n";
        
        for(int i = 0; i<10; i++){       
            for( int j = 0 ; j < 10 ; j++)
            {                
                Pion p = damier[i][j].getPion();
                if(p != null){
                    if( p.getCouleur() == Pion.CouleurPion.BLANC )
                        mess += " B ";
                    else
                    mess += " N "; 
                }
                else
                    mess += " - ";                
            }
            mess += "\n";
        }        
        return mess;
    }
    
    public boolean mouvement(int ligne_pion, int colonne_pion, int ligne_case, int colonne_case){
        boolean ret = false;
        
        if( damier[ligne_pion][colonne_pion].getPion() == null)
            return false;
        
        Pion p = damier[ligne_pion][colonne_pion].getPion();
        
        if( tourBlanc )
        {
            if(p.getCouleur() == Pion.CouleurPion.BLANC) // Si on a bien sélectionné un pion blanc
            {                
                if(!listePionBlancObligatoire.isEmpty() && !listePionBlancObligatoire.contains(p))
                    return false;
                
                // On regarde si c'est un pion
                if(damier[ligne_pion][colonne_pion].getPion().isDame() == false ){
                    
                    // On regarde si la position choisit est correcte, il y a 6 cas possibles:
                    //  1- Position en haut à droite, case vide (ligne_case = ligne_pion - 1 , colonne_case = colonne_pion + 1)
                    //  2- Position en haut à gauche, case vide (ligne_case = ligne_pion - 1 , colonne_case = colonne_pion - 1)
                    //  3- Saut par dessus un pion noir en haut à droite (ligne_case = ligne_pion - 2 , colonne_case = colonne_pion + 2)
                    //  4- Saut par ssus un pion noir en haut à gauche (ligne_case = ligne_pion - 2 , colonne_case = colonne_pion - 2)
                    //  5- Saut par dessus un pion noir en bas à droite (ligne_case = ligne_pion + 2 , colonne_case = colonne_pion + 2)
                    //  6- Saut par dessus un pion noir en bas à gauche (ligne_case = ligne_pion + 2 , colonne_case = colonne_pion - 2)
                    
                    // 1 : 
                    if(damier[ligne_case][colonne_case].getPion() == null){
                        if(ligne_case == ligne_pion - 1 && colonne_case == colonne_pion + 1)
                        {
                            damier[ligne_pion][colonne_pion].setPion(null);
                            damier[ligne_case][colonne_case].setPion(p);
                            tourBlanc = false;
                            ret = true;
                            chercherPionNoirObligatoire();
                            
                        // 2 :
                        }else if(ligne_case == ligne_pion - 1 && colonne_case == colonne_pion - 1){                                                       
                            damier[ligne_pion][colonne_pion].setPion(null);
                            damier[ligne_case][colonne_case].setPion(p);
                            tourBlanc = false;
                            ret = true;
                            chercherPionNoirObligatoire();
                        
                        // 3 :
                        }else if(ligne_case == ligne_pion - 2 && colonne_case == colonne_pion + 2){
                            if(damier[ligne_pion-1][colonne_pion+1].getPion() != null){// Si la case en haut à droite contient un pion
                                Pion p2 = damier[ligne_pion-1][colonne_pion+1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.NOIR){ // Si la case en haut à droite contient un pion noir
                                    damier[ligne_pion-1][colonne_pion+1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = false;
                                        chercherPionNoirObligatoire();
                                    }
                                    ret = true;
                                }
                            }
                        // 4 :
                        }else if(ligne_case == ligne_pion - 2 && colonne_case == colonne_pion - 2){
                            if(damier[ligne_pion-1][colonne_pion-1].getPion() != null){// Si la case en haut à gauche contient un pion
                                Pion p2 = damier[ligne_pion-1][colonne_pion-1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.NOIR){ // Si la case en haut à gauche contient un pion noir
                                    damier[ligne_pion-1][colonne_pion-1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = false;
                                        chercherPionNoirObligatoire();
                                    }
                                    ret = true;
                                }
                            }

                        // 5 :
                        }else if(ligne_case == ligne_pion + 2 && colonne_case == colonne_pion + 2){
                            if(damier[ligne_pion+1][colonne_pion+1].getPion() != null){// Si la case en bas à droite contient un pion
                                Pion p2 = damier[ligne_pion+1][colonne_pion+1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.NOIR){ // Si la case en en bas à droite contient un pion noir
                                    damier[ligne_pion+1][colonne_pion+1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = false;
                                        chercherPionNoirObligatoire();
                                    }
                                    ret = true;
                                }
                            }
                        // 6 :
                        }else if(ligne_case == ligne_pion + 2 && colonne_case == colonne_pion - 2){
                            if(damier[ligne_pion+1][colonne_pion-1].getPion() != null){// Si la case en bas à droite contient un pion
                                Pion p2 = damier[ligne_pion+1][colonne_pion-1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.NOIR){ // Si la case en en bas à droite contient un pion noir
                                    damier[ligne_pion+1][colonne_pion-1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = false;
                                        chercherPionNoirObligatoire();
                                    }
                                    ret = true;
                                }
                            }
                        }
                        
                        if(ret == true && ligne_case == 0) // si on a réussi à déplacer le pion, et qu'il est sur une case tout en haut
                        {
                            p.setDame();
                            damier[ligne_case][colonne_case].setPion(p);                            
                        }
                    }
                    
                }// On regarde si c'est une dame
                else{                    
                    if(damier[ligne_case][colonne_case].getPion() == null){ // Si la case de déplacement est vide
                        
                        if(Math.abs(ligne_pion - ligne_case) != Math.abs(colonne_pion - colonne_case))
                            return false;
                        
                        int i = ligne_pion;
                        int j = colonne_pion;
                        int nb_pion_noir = 0;                        
                        int nb_pion_blanc = 0;
                        
                        int []dir = new int[2];
                        int []pos_pion = new int[2];
                        
                        if(ligne_pion  > ligne_case)
                            dir[0] = -1; // On monte
                        else
                            dir[0] = 1; // On descend
                                    
                        if(colonne_pion  > colonne_case)
                            dir[1] = -1; // on va à gauche
                        else
                            dir[1] = 1; // on va à droite
                        
                        i += dir[0];
                        j += dir[1];
                        
                        while(i != ligne_case && j != colonne_case){
                            
                            if(damier[i][j].getPion() != null)
                                if(damier[i][j].getPion().getCouleur() == Pion.CouleurPion.BLANC){
                                    nb_pion_blanc ++;
                                }else{
                                    nb_pion_noir ++;
                                    pos_pion[0] = i; pos_pion[1] = j;
                                }
                            
                            i += dir[0];
                            j += dir[1];
                        }
                            
                        if(nb_pion_blanc == 0 && nb_pion_noir <= 1){
                            
                            // 1- On déplace la dame
                            damier[ligne_pion][colonne_pion].setPion(null);
                            damier[ligne_case][colonne_case].setPion(p);
                            
                            // 2- On supprimme le pion noir si il y en a un
                            if( nb_pion_noir == 1){
                                listePionsNoir.remove(damier[pos_pion[0]][pos_pion[1]].getPion());
                                damier[pos_pion[0]][pos_pion[1]].setPion(null);
                                
                                if(!chaineDame(p,ligne_case,colonne_case)){
                                    tourBlanc = false;
                                    chercherPionNoirObligatoire();
                                }
                            }else{                            
                                tourBlanc = false;
                            }
                            ret = true;
                            System.out.print("déplacer dame");
                        }
                    }                    
                }
                
            }            
        }else if(p.getCouleur() == Pion.CouleurPion.NOIR ){
            
            if(!listePionNoirObligatoire.isEmpty() && !listePionNoirObligatoire.contains(p))
                    return false;
            
            // On regarde si c'est un pion
            if(damier[ligne_pion][colonne_pion].getPion().isDame() == false ){
                                    
                    // On regarde si la position choisit est correcte, il y a 6 cas possibles:
                    //  1- Position en bas à droite, case vide (ligne_case = ligne_pion + 1 , colonne_case = colonne_pion + 1)
                    //  2- Position en bas à gauche, case vide (ligne_case = ligne_pion + 1 , colonne_case = colonne_pion - 1)
                    //  3- Saut par dessus un pion noir en bas à droite (ligne_case = ligne_pion + 2 , colonne_case = colonne_pion + 2)
                    //  4- Saut par ssus un pion noir en bas à gauche (ligne_case = ligne_pion + 2 , colonne_case = colonne_pion - 2)
                    //  5- Saut par dessus un pion noir en haut à droite (ligne_case = ligne_pion - 2 , colonne_case = colonne_pion + 2)
                    //  6- Saut par dessus un pion noir en haut à gauche (ligne_case = ligne_pion - 2 , colonne_case = colonne_pion - 2)
                    
                    // 1 : 
                    if(damier[ligne_case][colonne_case].getPion() == null){
                        if(ligne_case == ligne_pion + 1 && colonne_case == colonne_pion + 1)
                        {
                            damier[ligne_pion][colonne_pion].setPion(null);
                            damier[ligne_case][colonne_case].setPion(p);
                            tourBlanc = true;
                            ret = true;
                            chercherPionBlancObligatoire();
                            
                        // 2 :
                        }else if(ligne_case == ligne_pion + 1 && colonne_case == colonne_pion - 1){                                                       
                            damier[ligne_pion][colonne_pion].setPion(null);
                            damier[ligne_case][colonne_case].setPion(p);
                            tourBlanc = true;
                            ret = true;
                            chercherPionBlancObligatoire();
                        
                        // 3 :
                        }else if(ligne_case == ligne_pion - 2 && colonne_case == colonne_pion + 2){
                            if(damier[ligne_pion-1][colonne_pion+1].getPion() != null){// Si la case en haut à droite contient un pion
                                Pion p2 = damier[ligne_pion-1][colonne_pion+1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.BLANC){ // Si la case en haut à droite contient un pion noir
                                    damier[ligne_pion-1][colonne_pion+1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = true;
                                        chercherPionBlancObligatoire();
                                    }
                                    ret = true;
                                }
                            }
                        // 4 :
                        }else if(ligne_case == ligne_pion - 2 && colonne_case == colonne_pion - 2){
                            if(damier[ligne_pion-1][colonne_pion-1].getPion() != null){// Si la case en haut à gauche contient un pion
                                Pion p2 = damier[ligne_pion-1][colonne_pion-1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.BLANC){ // Si la case en haut à gauche contient un pion noir
                                    damier[ligne_pion-1][colonne_pion-1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = true;
                                        chercherPionBlancObligatoire();
                                    }
                                    ret = true;
                                }
                            }

                        // 5 :
                        }else if(ligne_case == ligne_pion + 2 && colonne_case == colonne_pion + 2){
                            if(damier[ligne_pion+1][colonne_pion+1].getPion() != null){// Si la case en bas à droite contient un pion
                                Pion p2 = damier[ligne_pion+1][colonne_pion+1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.BLANC){ // Si la case en en bas à droite contient un pion noir
                                    damier[ligne_pion+1][colonne_pion+1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = true;
                                        chercherPionBlancObligatoire();
                                    }
                                    ret = true;
                                }
                            }
                        // 6 :
                        }else if(ligne_case == ligne_pion + 2 && colonne_case == colonne_pion - 2){
                            if(damier[ligne_pion+1][colonne_pion-1].getPion() != null){// Si la case en bas à droite contient un pion
                                Pion p2 = damier[ligne_pion+1][colonne_pion-1].getPion();
                                if(p2.getCouleur() == Pion.CouleurPion.BLANC){ // Si la case en en bas à droite contient un pion noir
                                    damier[ligne_pion+1][colonne_pion-1].setPion(null);
                                    listePionsNoir.remove(p2);
                                    damier[ligne_pion][colonne_pion].setPion(null);
                                    damier[ligne_case][colonne_case].setPion(p);
                                    
                                    if(!chainePion(p,ligne_case,colonne_case)){
                                        tourBlanc = true;
                                        chercherPionBlancObligatoire();
                                    }
                                    ret = true;
                                }
                            }
                        }
                    }
                    
                    if(ret == true && ligne_case == 9) // si on a réussi à déplacer le pion, et qu'il est sur une case tout en haut
                    {
                        p.setDame();
                        damier[ligne_case][colonne_case].setPion(p);                        
                    }
            }// On regarde si c'est une dame
            else{                    
                    if(damier[ligne_case][colonne_case].getPion() == null){ // Si la case de déplacement est vide
                        
                        if(Math.abs(ligne_pion - ligne_case) != Math.abs(colonne_pion - colonne_case))
                            return false;
                        
                        int i = ligne_pion;
                        int j = colonne_pion;
                        int nb_pion_noir = 0;                        
                        int nb_pion_blanc = 0;
                        
                        int []dir = new int[2];
                        int []pos_pion = new int[2];
                        
                        if(ligne_pion  > ligne_case)
                            dir[0] = -1; // On monte
                        else
                            dir[0] = 1; // On descend
                                    
                        if(colonne_pion  > colonne_case)
                            dir[1] = -1; // on va à gauche
                        else
                            dir[1] = 1; // on va à droite
                        
                        i += dir[0];
                        j += dir[1];
                        
                        while(i != ligne_case+dir[0] && j != colonne_case+dir[1]){
                            
                            if(damier[i][j].getPion() != null)
                                if(damier[i][j].getPion().getCouleur() == Pion.CouleurPion.BLANC){
                                    nb_pion_blanc ++;
                                    pos_pion[0] = i; pos_pion[1] = j;
                                }else{
                                    nb_pion_noir ++;
                                    
                                }
                            
                            i += dir[0];
                            j += dir[1];
                        }
                            
                        if(nb_pion_blanc <= 1 && nb_pion_noir == 0){
                            
                            // 1- On déplace la dame
                            damier[ligne_pion][colonne_pion].setPion(null);
                            damier[ligne_case][colonne_case].setPion(p);
                            
                            // 2- On supprimme le pion noir si il y en a un
                            if( nb_pion_blanc == 1){
                                listePionsNoir.remove(damier[pos_pion[0]][pos_pion[1]].getPion());
                                damier[pos_pion[0]][pos_pion[1]].setPion(null);
                                
                                if(!chaineDame(p,ligne_case,colonne_case)){
                                    tourBlanc = true;
                                    chercherPionBlancObligatoire();
                                }
                            }else{                            
                                tourBlanc = true;
                            }
                            ret = true;
                            System.out.print("déplacer dame");
                        }
                    }                    
                }
            
        }
            
        return ret;
    }
    
    public boolean blancGagne(){
        return listePionsBlanc.isEmpty();
    }
    
    public boolean noirGagne(){
        return listePionsNoir.isEmpty();
    }
    
    private boolean chainePion(Pion p,int ligne, int colonne){ // Permet de savoir si il y a plusieurs pion à manger
        
        // en haut à droite        
        if(ligne - 2 >= 0 && colonne + 2 < 10 && damier[ligne-2][colonne+2].getPion() == null && damier[ligne-1][colonne+1].getPion() != null){
            if(damier[ligne-1][colonne+1].getPion().getCouleur() != p.getCouleur())
                return true;            
        }
        // en haut à gauche
        if( ligne -2 >= 0 && colonne -2 >= 0 && damier[ligne-2][colonne-2].getPion() == null && damier[ligne-1][colonne-1].getPion() != null){
            if(damier[ligne-1][colonne-1].getPion().getCouleur() != p.getCouleur())
                return true;
        }
        // en bas à droite
        else if(ligne +2 < 10 && colonne +2 < 10 && damier[ligne+2][colonne+2].getPion() == null && damier[ligne+1][colonne+1].getPion() != null){
            if(damier[ligne+1][colonne+1].getPion().getCouleur() != p.getCouleur())
                return true;
        }
        // en bas à gauche
        else if(ligne + 2 < 10 && colonne - 2 >= 0 && damier[ligne+2][colonne-2].getPion() == null && damier[ligne+1][colonne-1].getPion() != null){
            if(damier[ligne+1][colonne-1].getPion().getCouleur() != p.getCouleur())
                return true;
        }
        return false;
        
        // Si c'est à true mettre le pion actuel comme étant le seul pion que l'on peut choisir
        
    }
    
    private boolean chaineDame(Pion p,int ligne, int colonne){
        
        int i, i_max;
        int j, j_max;
        int []dir = new int[2];
        boolean pion_present = false;
        

       /*
            dir[0] = -1; // On monte        
            dir[0] = 1; // On descend        
            dir[1] = -1; // on va à gauche       
            dir[1] = 1; // on va à droite
        */
        
        // en haut à droite
        
        dir[0] = -1;
        dir[1] = 1;
        
        i = ligne + dir[0]; j = colonne + dir[1];
        i_max = 0; j_max = 9;
        
        while( i < i_max && j < j_max){
            
            if(damier[i][j].getPion() != null){
                if(pion_present)
                    return false;
                else if(damier[i][j].getPion().getCouleur() == p.getCouleur())
                    return false;
                else
                    pion_present = true;                    
            }else{
                if(pion_present)
                    return true;
            }
            i+=dir[0];j+=dir[1];
        }
        
        // en haut à gauche        
        dir[0] = -1;
        dir[1] = -1;
        
        
        i = ligne + dir[0]; j = colonne + dir[1];
        i_max = 0; j_max = 0;
        
        while( i < i_max && j < j_max){
            
            if(damier[i][j].getPion() != null){
                if(pion_present)
                    return false;
                else if(damier[i][j].getPion().getCouleur() == p.getCouleur())
                    return false;
                else
                    pion_present = true;                    
            }else{
                if(pion_present)
                    return true;
            }
            i+=dir[0];j+=dir[1];
        }
        
        // en bas à droite
        dir[0] = 1;
        dir[1] = 1;
        
        i = ligne + dir[0]; j = colonne + dir[1];
        i_max = 9; j_max = 9;
        
        while( i < i_max && j < j_max){
            
            if(damier[i][j].getPion() != null){
                if(pion_present)
                    return false;
                else if(damier[i][j].getPion().getCouleur() == p.getCouleur())
                    return false;
                else
                    pion_present = true;                    
            }else{
                if(pion_present)
                    return true;
            }
            i+=dir[0];j+=dir[1];
        }
        
        // en bas à gauche
        dir[0] = 1;
        dir[1] = -1;
        
        i = ligne + dir[0]; j = colonne + dir[1];
        i_max = 9; j_max = 0;
        
        while( i < i_max && j < j_max){
            
            if(damier[i][j].getPion() != null){
                if(pion_present)
                    return false;
                else if(damier[i][j].getPion().getCouleur() == p.getCouleur())
                    return false;
                else
                    pion_present = true;                    
            }else{
                if(pion_present)
                    return true;
            }
            i+=dir[0];j+=dir[1];
        }
        
        
        
        return false;
    }
    
    private void chercherPionBlancObligatoire(){
        listePionBlancObligatoire.clear(); // On vide notre liste
        for(int i = 0; i<10; i++)        
            for( int j = 0 ; j < 10 ; j++)
            {  
               // Si la case contient un pion blanc 
               if(damier[i][j].getPion() != null 
                       && damier[i][j].getPion().getCouleur() == Pion.CouleurPion.BLANC
                       && damier[i][j].getPion().isDame() == false
                       && chainePion(damier[i][j].getPion(), i, j))                   
                   listePionBlancObligatoire.add(damier[i][j].getPion());
               else if(damier[i][j].getPion() != null 
                       && damier[i][j].getPion().getCouleur() == Pion.CouleurPion.BLANC
                       && damier[i][j].getPion().isDame() == true
                       && chaineDame(damier[i][j].getPion(), i, j))  
                    listePionBlancObligatoire.add(damier[i][j].getPion());   
                       
            }        
    }
    
    private void chercherPionNoirObligatoire(){
        listePionNoirObligatoire.clear(); // On vide notre liste
        for(int i = 0; i<10; i++)        
            for( int j = 0 ; j < 10 ; j++)
            {  
               // Si la case contient un pion blanc 
               if(damier[i][j].getPion() != null 
                       && damier[i][j].getPion().getCouleur() == Pion.CouleurPion.NOIR
                       && damier[i][j].getPion().isDame() == false
                       && chainePion(damier[i][j].getPion(), i, j))                   
                   listePionNoirObligatoire.add(damier[i][j].getPion());
               else if(damier[i][j].getPion() != null 
                       && damier[i][j].getPion().getCouleur() == Pion.CouleurPion.NOIR
                       && damier[i][j].getPion().isDame() == true
                       && chaineDame(damier[i][j].getPion(), i, j))  
                    listePionNoirObligatoire.add(damier[i][j].getPion());   
                       
            }
    }
    
}
